using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("TurnStartManager")]
	public class TurnStartManager : MonoBehaviour
	{
		[Attribute38("TurnStartManager.CardChange")]
		public class CardChange : MonoClass
		{
			public Card m_card => method_3<Card>("m_card");

			public TagDelta m_tagDelta => method_3<TagDelta>("m_tagDelta");

			public CardChange(IntPtr address, string className)
				: base(address, className)
			{
			}

			public CardChange(IntPtr address)
				: this(address, "CardChange")
			{
			}
		}

		public TurnStartIndicator m_turnStartPrefab => method_3<TurnStartIndicator>("m_turnStartPrefab");

		public Spell m_OpponentExtraTurnSpell => method_3<Spell>("m_OpponentExtraTurnSpell");

		public Spell m_FriendlyExtraTurnSpell => method_3<Spell>("m_FriendlyExtraTurnSpell");

		public TurnStartIndicator m_turnStartInstance => method_3<TurnStartIndicator>("m_turnStartInstance");

		public Spell m_opponentExtraTurnSpellInstance => method_3<Spell>("m_opponentExtraTurnSpellInstance");

		public Spell m_friendlyExtraTurnSpellInstance => method_3<Spell>("m_friendlyExtraTurnSpellInstance");

		public bool m_listeningForTurnEvents => method_2<bool>("m_listeningForTurnEvents");

		public int m_manaCrystalsGained => method_2<int>("m_manaCrystalsGained");

		public int m_manaCrystalsFilled => method_2<int>("m_manaCrystalsFilled");

		public List<Card> m_cardsToDraw => method_3<Class271<Card>>("m_cardsToDraw")?.method_25();

		public List<CardChange> m_exhaustedChangesToHandle => method_3<Class271<CardChange>>("m_exhaustedChangesToHandle")?.method_25();

		public SpellController m_spellController => method_3<SpellController>("m_spellController");

		public bool m_blockingInput => method_2<bool>("m_blockingInput");

		public bool m_twoScoopsDisplayed => method_2<bool>("m_twoScoopsDisplayed");

		public TurnStartManager(IntPtr address, string className)
			: base(address, className)
		{
		}

		public TurnStartManager(IntPtr address)
			: this(address, "TurnStartManager")
		{
		}

		public static TurnStartManager Get()
		{
			return MonoClass.smethod_15<TurnStartManager>(TritonHs.MainAssemblyPath, "", "TurnStartManager", "Get", Array.Empty<object>());
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void OnDestroy()
		{
			method_8("OnDestroy");
		}

		public bool IsListeningForTurnEvents()
		{
			return method_11<bool>("IsListeningForTurnEvents", Array.Empty<object>());
		}

		public void BeginListeningForTurnEvents()
		{
			method_8("BeginListeningForTurnEvents");
		}

		public void NotifyOfManaCrystalGained(int amount)
		{
			method_8("NotifyOfManaCrystalGained", amount);
		}

		public void NotifyOfManaCrystalFilled(int amount)
		{
			method_8("NotifyOfManaCrystalFilled", amount);
		}

		public void NotifyOfCardDrawn(Entity drawnEntity)
		{
			method_8("NotifyOfCardDrawn", drawnEntity);
		}

		public void NotifyOfExhaustedChange(Card card, TagDelta tagChange)
		{
			method_8("NotifyOfExhaustedChange", card, tagChange);
		}

		public Spell GetExtraTurnSpell(bool isFriendly)
		{
			return method_14<Spell>("GetExtraTurnSpell", new object[1] { isFriendly });
		}

		public Spell SetExtraTurnSpell(Spell extraTurnSpell, bool isFriendly)
		{
			return method_14<Spell>("SetExtraTurnSpell", new object[2] { extraTurnSpell, isFriendly });
		}

		public void NotifyOfExtraTurn(Spell extraTurnSpell, bool isEnding, bool isFriendly)
		{
			method_8("NotifyOfExtraTurn", extraTurnSpell, isEnding, isFriendly);
		}

		public void NotifyOfSpellController(SpellController spellController)
		{
			method_8("NotifyOfSpellController", spellController);
		}

		public SpellController GetSpellController()
		{
			return method_14<SpellController>("GetSpellController", Array.Empty<object>());
		}

		public int GetNumCardsToDraw()
		{
			return method_11<int>("GetNumCardsToDraw", Array.Empty<object>());
		}

		public List<Card> GetCardsToDraw()
		{
			return method_14<Class271<Card>>("GetCardsToDraw", Array.Empty<object>())?.method_25();
		}

		public bool IsCardDrawHandled(Card card)
		{
			return method_11<bool>("IsCardDrawHandled", new object[1] { card });
		}

		public void BeginPlayingTurnEvents()
		{
			method_8("BeginPlayingTurnEvents");
		}

		public void NotifyOfTriggerVisual()
		{
			method_8("NotifyOfTriggerVisual");
		}

		public bool IsBlockingInput()
		{
			return method_11<bool>("IsBlockingInput", Array.Empty<object>());
		}

		public bool IsTurnStartIndicatorShowing()
		{
			return method_11<bool>("IsTurnStartIndicatorShowing", Array.Empty<object>());
		}

		public void DisplayTwoScoops()
		{
			method_8("DisplayTwoScoops");
		}

		public bool HasActionsAfterCardDraw()
		{
			return method_11<bool>("HasActionsAfterCardDraw", Array.Empty<object>());
		}

		public void HandleExhaustedChanges()
		{
			method_8("HandleExhaustedChanges");
		}

		public void OnGameOver(TAG_PLAYSTATE playState, object userData)
		{
			method_8("OnGameOver", playState, userData);
		}
	}
}
